Self-healing data protection system matching system attributes to relevant scripts using multiple scripts

ABSTRACT

Embodiments automate the timely remediation of issues by matching failed operations to a script or set of scripts that is configured to fix the problem. A method detects a backup operation alert message sent from a data manager or storage system that encodes one or more attributes affected by the backup operation, wherein the attributes are weighted to reflect a percentage importance of the a corresponding script to fix the problem. A script library is scanned to identify scripts that match the alert message. A component generates a score for each script, where the score factors the relevance of the script to the backup operation based on the weighted attributes. Scores for each single script each possible combination of multiple scripts are computed and compared, and the script or script combination with the highest score is executed by the self-healing process.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a Continuation-In-Part application and claims priority to U.S. patent application Ser. No. 17/955,802 filed on Sep. 29, 2022 and entitled “Self-Healing Data Protection System Matching System Attributes to Relevant Scripts Using Weighted Attributes,” which in turn is a Continuation-In-Part application and claims priority to U.S. patent application Ser. No. 17/874,868 filed on Jul. 27, 2022 and entitled “Self-Healing Data Protection System Matching System Attributes in Alert Messages to Relevant Scripts,” which are both assigned to the assignee of the present application, and which is hereby incorporated by reference in its entirety.

TECHNICAL FIELD

Embodiments are generally directed to data protection systems, and more specifically to matching failed operations to remedial scripts without causing side effects.

BACKGROUND

Large-scale data protection systems, such as cloud data protection systems backup and restore large amounts of data from large numbers of different and disparate backup clients. Established products, such as the PowerProtect Data Manager system from DellEMC provided software defined data protection, automated discovery, deduplication, and IT governance for physical, virtual, and cloud environments. When provided as a business or enterprise platform, such systems may support many clients and customers with different data backup and processing needs. During typical usage deployments, it is common for certain users to encounter problems or issues with data backups or restores. Current troubleshooting of issues within current data protection consoles and systems often requires a user to call technical support personnel to provide guidance or fix these issues. Such a technical support or IT group may maintain a large database of known issues and their corresponding potential solutions.

Many systems utilize scripts or macros that can address and automatically solve many issues that may be encountered in a system. However, such scripts may also affect other parts of the system besides the element causing or associated with the issue. In this case, simply executing a likely relevant script may create additional issues.

What is needed, therefore, is a system and method automatically and timely addresses issues through a process that matches failed operations to scripts that are most likely to fix a problem without causing other issues or side effects.

The subject matter discussed in the background section should not be assumed to be prior art merely as a result of its mention in the background section. Similarly, a problem mentioned in the background section or associated with the subject matter of the background section should not be assumed to have been previously recognized in the prior art. The subject matter in the background section merely represents different approaches, which in and of themselves may also be inventions. EMC, Data Domain, Data Domain Restorer, and PowerProtect Data Manager are trademarks of Dell EMC Corporation.

BRIEF DESCRIPTION OF THE DRAWINGS

In the following drawings like reference numerals designate like structural elements. Although the figures depict various examples, the one or more embodiments and implementations described herein are not limited to the examples depicted in the figures.

FIG. 1 is a diagram of a data protection system implementing a self-healing process, under some embodiments.

FIG. 2 illustrates a PowerProtect data manager system that implements a self-healing process, under some embodiments.

FIG. 3 is a flowchart that illustrates a method of processing an issue alert using a self-healing service (SHS), under some embodiment.

FIG. 4 illustrates a matching operation of alert messages to scripts in an example embodiment.

FIG. 5 is a flowchart illustrating a process of issuing an alert through a self-healing process using weighted attributes in scripts, under some embodiments.

FIG. 6 is a flowchart illustrating a process of issuing an alert through a self-healing process using weighted attributes for multiple scripts, under some embodiments.

FIG. 7 is a flowchart that illustrates a process of calculating a score for multiple scripts, under some embodiments.

FIG. 8 is a system block diagram of a computer system used to execute one or more software components described herein, under some embodiments.

DETAILED DESCRIPTION

A detailed description of one or more embodiments is provided below along with accompanying figures that illustrate the principles of the described embodiments. While aspects of the invention are described in conjunction with such embodiment(s), it should be understood that it is not limited to any one embodiment. On the contrary, the scope is limited only by the claims and the invention encompasses numerous alternatives, modifications, and equivalents. For the purpose of example, numerous specific details are set forth in the following description in order to provide a thorough understanding of the described embodiments, which may be practiced according to the claims without some or all of these specific details. For the purpose of clarity, technical material that is known in the technical fields related to the embodiments has not been described in detail so that the described embodiments are not unnecessarily obscured.

It should be appreciated that the described embodiments can be implemented in numerous ways, including as a process, an apparatus, a system, a device, a method, or a computer-readable medium such as a computer-readable storage medium containing computer-readable instructions or computer program code, or as a computer program product, comprising a computer-usable medium having a computer-readable program code embodied therein. In the context of this disclosure, a computer-usable medium or computer-readable medium may be any physical medium that can contain or store the program for use by or in connection with the instruction execution system, apparatus or device. For example, the computer-readable storage medium or computer-usable medium may be, but is not limited to, a random access memory (RAM), read-only memory (ROM), or a persistent store, such as a mass storage device, hard drives, CDROM, DVDROM, tape, erasable programmable read-only memory (EPROM or flash memory), or any magnetic, electromagnetic, optical, or electrical means or system, apparatus or device for storing information. Alternatively or additionally, the computer-readable storage medium or computer-usable medium may be any combination of these devices or even paper or another suitable medium upon which the program code is printed, as the program code can be electronically captured, via, for instance, optical scanning of the paper or other medium, then compiled, interpreted, or otherwise processed in a suitable manner, if necessary, and then stored in a computer memory. Applications, software programs or computer-readable instructions may be referred to as components or modules. Applications may be hardwired or hard coded in hardware or take the form of software executing on a general purpose computer or be hardwired or hard coded in hardware such that when the software is loaded into and/or executed by the computer, the computer becomes an apparatus for practicing the invention. Applications may also be downloaded, in whole or in part, through the use of a software development kit or toolkit that enables the creation and implementation of the described embodiments. In this specification, these implementations, or any other form that the invention may take, may be referred to as techniques. In general, the order of the steps of disclosed processes may be altered within the scope of the invention.

As stated above, fixing user issues in present large-scale data protection systems can often require extensive person-to-person interaction between users and tech support personnel. Embodiments reduce the need for such manual and human-based interaction by providing a data protection console that is itself directly connected to a support remediation knowledge database so that it could leverage a wide range of current console metrics to identify reasons for an issue. Once a source of the issue has been identified, automated script execution processes will implement the proposed fix by running scripts within the user environment to perform self-healing of the system.

Some embodiments of the invention involve data processing and storage in a distributed system, such as a cloud based network system or very large-scale wide area network (WAN), metropolitan area network (MAN), however, those skilled in the art will appreciate that embodiments are not limited thereto, and may include smaller-scale networks, such as LANs (local area networks). Thus, aspects of the one or more embodiments described herein may be implemented on one or more computers executing software instructions, and the computers may be networked in a client-server arrangement or similar distributed computer network.

Embodiments are described for a method to provide automatic diagnosis and self-healing or remediation of data processing problems in a data protection system. FIG. 1 illustrates a data protection system that implements a self-healing process under some embodiments. In system 100, a storage server 102 executes a data storage or backup management process 112 that coordinates or manages the backup of data from one or more data sources 108 to storage devices, such as network storage 114, client storage, and/or virtual storage devices 104. With regard to virtual storage 114, any number of virtual machines (VMs) or groups of VMs (e.g., organized into virtual centers) may be provided to serve as backup targets. The VMs or other network storage devices serve as target storage devices for data backed up from one or more data sources, such as storage server 102 or data source 106, in the network environment. The data sourced by the data source may be any appropriate data, such as database data that is part of a database management system, and the data may reside on one or more hard drives for the database(s) in a variety of formats. Thus, data source 106 maybe a database server executing one or more database processes 116, or it may be any other sources data for use by the resources of network 100.

The network server computers are coupled directly or indirectly to the data storage 114, target VMs 104, and the data sources and other resources through network 110, which is typically a cloud network (but may also be a LAN, WAN or other appropriate network). Network 110 provides connectivity to the various systems, components, and resources of system 100, and may be implemented using protocols such as Transmission Control Protocol (TCP) and/or Internet Protocol (IP), well known in the relevant arts. In a cloud computing environment, network 110 represents a network in which applications, servers and data are maintained and provided through a centralized cloud computing platform.

In an embodiment, cloud network 110 may be a private network or it may be a public network provided by a third-party cloud service provider (CSP) 108. The data generated or sourced by system 100 and transmitted over network 110 may be stored in any number of persistent storage locations and devices. In a backup case, the backup process 112 causes or facilitates the backup of this data to other storage devices of the network, such as network storage 114, which may at least be partially implemented through storage device arrays, such as RAID components. In an embodiment network 100 may be implemented to provide support for various storage architectures such as storage area network (SAN), Network-attached Storage (NAS), or Direct-attached Storage (DAS) that make use of large-scale network accessible storage devices 114, such as large capacity disk (optical or magnetic) arrays.

In an embodiment, system 100 may represent a Data Domain Restorer (DDR)-based deduplication storage system, and storage server 102 may be implemented as a DDR Deduplication Storage server provided by EMC Corporation. However, other similar backup and storage systems are also possible. In general, Data Domain is a purpose-built backup appliance providing streaming deduplication that is able to ingest data at full network speeds, from multiple backup sources while providing storage efficiency. Present Data Domain systems are able to use tiered data storage technologies, such as very large multi-terabyte SATA drive trays, or SSD-enabled fast ingest trays. Data Domain has a logical extension to its file system and MTree organization which allows a data movement policy to be applied to aging backup content.

Deduplication backup systems, such as the DellEMC Data Domain system use deduplication techniques as a form of single-instance storage that eliminates redundant copies of data to reduce storage overhead. Data compression methods are used to store only one unique instance of data by replacing redundant data blocks with pointers to the unique data copy. As new data is written to a system, duplicate chunks are replaced with these pointer references to previously stored data.

In an embodiment, the deduplication backup system 100 of FIG. 1 is implemented as part of a comprehensive data protection platform, such as the Dell EMC PowerProtect data manager system. This data manager system represents a next generation data management system that provides trusted data protection for workloads and file systems running on-premises with self-service capabilities for operational efficiency and IT governance controls to ensure compliance. SaaS-based management interfaces are provided to easily monitor, analyze and troubleshoot distributed data protection environments.

FIG. 2 illustrates a PowerProtect data manager system that implements a self-healing process, under some embodiments. In system 200, the data manager component 202 provides ability to discover, manage, monitor data protection and replication for filesystem assets, such as provided or accessed by filesystem host 206 through integration the file system agent 207. Filesystem assets, such as filesystems 208 a, databases 208 b, applications 208 c, and any other relevant data are protected in with system with centralized and self-service file system protection features. The data manager 202 enables a user, such as system (or IT) admin staff 204 to perform backup and restore using certain self-service CLI (command line interface) workflows for Windows and Linux (or similar) assets.

Data is backed up from and restored to the data sources from storage (e.g., Data Domain appliances) 212, which stores filesystem data and metadata. The data manager is configured to support various levels of data backups, such as block-based and file-based filesystem support for different operating systems, e.g., Windows (NTFS, ReFS) and Linux (Ext3, Ext4 and XFS), etc. It also provides centralized filesystem backup and recovery (volume and file level), as well as centralized file level restores of block-based file system backups.

In an embodiment, the data manager 202 provides a console 206 including a graphical user interface (GUI) component that allows users to set protection policies, perform backup and recovery operations, deduplicate workloads and file systems, and so on. Filesystem backup configuration can be done by a backup administrator 204 through protection lifecycle policies set on the data manager 202. At the time of a scheduled backup, the data manager 202 requests the filesystem agent 207 to perform a save operation for filesystem data. The filesystem agent parses the backup job request and converts the request into appropriate (e.g., ddfssv) utility commands and performs the save operation. The filesystem agent 207 creates/verifies the storage unit on the storage media 212. 5. Upon successful verification, the filesystem agent writes the file system data directly to the storage unit and sends the catalog details to catalog database 205 in the data manager 202. Other operations, such as data restores, replication, and so on, can be performed similarly in system 200.

The data manager system can be deployed as a stand-alone system, integrated appliance form factor, or in an Amazon Web Services (AWS) or similar system to protect in-cloud workloads. It can be configured to protect a variety of databases, Kubernetes container environments, VMware applications on-premises and in the cloud, as well as Windows NTFS and Linux filesystems. Although embodiments are described with respect to a Dell EMC PowerProtect Data Manager system, it should be noted embodiments are not so limited, and any similar data protection system may be used.

As stated above, any issues that arise with respect to data backup, restores, or other processing operations must typically be manually handled by the user and/or system administrator 204 through some form of personal interaction. For the embodiment of FIG. 2 , system 200 includes an issue remediation and self-healing process 210 that provides a direct interface between the console 203 and a support remediation knowledge database 214 that allows the data manager 202 to leverage a wide range of current console metrics to pinpoint the reason for an issue, and institute automatic remedial or corrective (fix) measures to address the current issue.

System 200 also includes scripts that are written and deployed to automatically perform certain tasks involving system resources and backup operations. Such scripts (also called macros) are sequences of program code that are automatically executed when triggered and generally execute without user interaction.

Embodiments of system 200 include a describes a process 112 that automates the timely remediation of issues by matching failed operations to a script that is configured to fix the problem or problems without causing additional side effects, thus minimizing unavailability of services/data and loss of data.

As shown in FIG. 2 , the data protection system 200 includes in an instance of backup software, such as implemented by the PowerProtect Data Manager 202, and one or more instances of protection storage 212, such as a PowerProtect Data Domain appliance. These elements run backup operations that will either succeed or fail. Example operations include backup data from a backup client to the storage, restore data from the storage to the client, and migrate data among storage and/or clients.

The system 200 has a set of attributes that are affected by operations. Attributes include backup client ID, storage unit ID, storage unit type, protected data type, backup policies, and so on. For example: when a backup operation runs, data is stored on a ‘storageUnit’ that has a specific ‘deviceType. Attributes can include, but are not limited to the following: (1) storage utilization, (2) CPU utilization, (3) device status (online/offline/locked), and (4) storage unit status (non-existent/full/unavailable), and other similar parameters.

Each system operation (e.g., backup, GC, restore, etc.) has a list of associated attributes, such as listed above. This list of attributes per operation are assigned by the vendor and stored in knowledge database 214, or other similar location. When an operation fails, process 210 executes. Operations that fail can generate alerts that show the system attributes affected by the operation. In an embodiment, either or both of the data manager 202 and storage 212 are configured to detect issues related to a currently executed backup operation. Once an issue is detected by either component, it will issue an appropriate alert message.

The alerts comprise text or graphical messages transmitted to the user through the GUI, or through another appropriate notification method. An alert may be provided in the following format (or equivalent): “attribute1=A attribute2=B [ . . . ].” For example: “Error: storage not found deviceType=DD storageUnit=ImportantData.” This provides a list of attributes per operation. Each script has a list of attribute and a weight.

Component 210 of system 200 includes a self-healing service (SHS) that implements a process operates on scripts that are acted on by the data protection system. In an embodiment, script library 220 contains scripts that are provided in any appropriate format, such as, Python script, bash shell script, etc. The scripts are written and stored for use by various possible entities or sources in the system, such as engineering personnel, technical support, administrators, etc.

The scripts contain information about the system attribute or attributes that it affects, and may contain this information in a header or other similar data element. For example: a Python script called createMissingStorageUnit.py has the line “#attributes: deviceType, storageUnit.”

The scripts are stored in a library 220 that is accessible to the data protection system such that the SHS can read and execute the scripts and the scripts can connect to and operate upon the PPDM 202 software and storage 212. For example, the script library can be located in a directory within an NFS file share. In general, the library 220 is not public or made publicly available so that it can contain sensitive information (login tokens, etc.). Alternatively, a portion may be made public for scripts that operate on non-sensitive information that may be needed for third party or outside use.

FIG. 3 is a flowchart that illustrates a method of processing an issue alert using a self-healing service (SHS), under some embodiment. The data manager or storage system will issue an alert for a failed operation, and this will be detected by the self-healing process 210 and SHS. Upon detection of such an alert, the SHS reads the attributes in the alert message, 304, and scans through the script library 220 and matches the failed operation to one or more scripts that are most likely to address or fix the issue without causing additional problems or side effects. In an embodiment, this is done by matching the attributes in the headers of all scripts to the attributes shown in the system attributes elements of the alert message. FIG. 4 illustrates a matching operation of alert messages to scripts in an example embodiment. As shown in FIG. 4 , an alert message 402 contains a number of attributes, and these are matched to attributes in the headers of scripts (e.g., Script 1, 2, 3) in the script library 404. This is thus is a match of attributes in an operation against the set of operations in each script to compute a score as described below.

The SHS then generates a score for each script that is found to match or most likely match the alert message, 308. In an embodiment, the score is calculated using the following Equation 1:

Score=((M/N)−(U*P))*100  [Equation 1]

In this equation:

N=number of attributes in the operation,

M=number of attributes in the script that also exist in the operation

U=number of attributes in the script that do not also exist in the operation

P=configurable penalty value (default=0.05)

The range of P is configurable, though it is typically much less than 1.0. The closer that the ratio (M/N) is to 1, the more likely the script is to be relevant to the operation, since the script will affect more of the attributes associated with the operation. If a script also affects attributes that are not associated with the operation, then it will have side effects on the system, which add risk of causing other problems by running that script. Therefore, each of those additional attributes add a penalty that reduces the likelihood of running the script. Once all the scores have been calculated the SHS executes the script with the highest score factoring in the penalties for scripts that affect attributes not associated with the operation, 310. In the event that two or more scripts are tied for the highest score, the SHS chooses one at random to execute, 310.

To illustrate this process 300, the following three example operations are provided. In this example:

Operation 1 has 4 Attributes, and Script A affects 4 Attributes, which all match Operation 1's Attributes; no other scripts match more than 3 Attributes, so Script A gets a Score of 100 and is run.

Operation 2 has 3 Attributes, and Script B affects 3 Attributes, which all match Operation 2's Attributes; however, Script B also affects 20 other Attributes 4 Script B gets a Score of 0 and is not run.

Operation 3 has 5 Attributes; Script C affects 4 Attributes, 3 of which match Operation 3's; Script D affects 3 Attributes, all of which match Operation 3's 4 Script D has a higher Score than Script C and Script D is run.

In an embodiment, certain remediation measures may be implemented. Some may be performed automatically, while others may require approval or human intervention. In an embodiment, the highest scoring script automatically performs the corrective or remediation process. This is typically done for less critical actions that can be taken automatically.

Occasionally, however solutions that are critical or drastic may require human awareness or approval may need extra processing besides automatic script execution. In this case, the system can notify the user with an option to implement the proposed solution (e.g., what worked last time and the option to initiate one of those options). An example of an action that would require human approval would be when a storage target is full, in which case, the solution may be to create more room by either a) running garbage collection and re-trying the backup, b) adding more storage, c) adjusting retention, or d) offloading some assets to another storage target. Some actions may be beyond the scope of the system administrator to implement (e.g., an operating system issue versus a backup issue). In such a case, the solution may be to direct the user to other personnel or provide documentation, and so on. This kind of solution might help mitigate the majority of solvable issues in a user environment, which will drive down tech support calls and increase customer satisfaction.

Weighted Attributes

In an embodiment, the attributes are weighted so that some attributes may be categorized and processed in a hierarchical order where some attributes are deemed more “important” than other attributes. The scripts can define which attributes have weights and how much they are weighted, and an updated algorithm includes weights in its calculations. The purpose of having weighted attributes is to help influence the algorithm to better determine which script should be used to resolve a particular problem.

As described above, and with reference to FIG. 2 , system 200 implementing self-healing process 210 comprises an instance of backup software (e.g., PowerProtect Data Manager 202) and one or more instances of protection storage (e.g., PowerProtect DD storage 212). This system executes a software or storage related operation, which either succeeds or fails, and there are a set of attributes that are affected by these operations. For example, when a backup runs, data is stored on a ‘storageUnit’ on storage with a ‘deviceType.’ Operations that fail generate alerts that show the system attributes affected by the operation in the format “attribute1=A attribute2=B [ . . . ].” For example: “Error: storage unit full deviceType=DD storageUnit=ImportantData.” The self-healing process 210 runs as a process within the Backup Software or as an independent entity.

As shown in FIG. 4 , the system includes a script library 404 that stores a set of scripts that, when executed, act upon the data protection system 200. There is no strict prescription for a specific script format, which can be, for example, Python script, bash shell script, etc., nor the authors or source of the script (e.g., Engineering, Technical Support, etc.). However, the scripts are required to contain information with a specified format in its header about the system attributes that it affects. For example: a Python script called createMissingStorageUnit.py has the line:

-   -   #attributes: deviceType[50], storageUnit[50]

In this embodiment, the attributes are weighted by a weight value provided as a numerical value after the attribute name, as in AttributeName [W], where ‘W’ is the weighting factor provided as a percentage value between 0 to 100. Thus, for the example above, [50] represents that the specific attribute has a weight of 50%, in this case both attributes are weighted 50%.

The sum of all the attributes' weights in a script must equal 100, and can be set to any appropriate percentage value per attribute. The attributes and the weights are pre-defined in the script by the author who is assumed to be a subject matter expert, and each operation lists the attributes affected, wherein the list is created by the vendor.

The scripts are stored in a location, such as the script library 220, which is accessible to the data protection system such that the self-healing process 210 can read and execute the scripts and the scripts can connect to and operate upon the backup software 202 and storage 212. For example, the scripts can be stored in a directory within an network filesystem (NFS) file share. In general, the library is not public, and can therefore contain sensitive information (e.g., login tokens, etc.). In cases where the library is not in a secure site, or is public, such sensitive information should not be contained therein, however, users can define library access privileges and data storage types depending on their needs.

FIG. 5 is a flowchart illustrating a process of issuing an alert through a self-healing process using weighted attributes in scripts, under some embodiments. As shown in FIG. 5 , process 500 begins with a failed operation issuing an alert, 502. Upon this event, the self-healing process scans through the script library and generates a score for each script, 504. In an embodiment, this score is calculated using the following formula, named the ‘ZAP’ formula:

Score=Z−(A*P)

In the above ZAP formula:

Z=the sum of all the weight values for each attribute in the script that also exists in the operation;

A=the sum of all the weight values for each attribute in the script that do not also exist in the operation; and

P=a configurable penalty value (default=0.05).

The score is calculated by determining or factoring in the weight values to derive the Z and A factors, 506. The score is then computed by multiplying the A and P factors and subtracting this product from the Z factor.

The closer the score is to 100, the more likely the script is to be relevant to the operation, since the script will affect more of the attributes associated with the operation.

If a script also affects attributes that are not associated with the operation, then it will have side effects on the system, which add risk of not actually fixing the problem. Therefore, each of those additional attributes add a penalty that reduces the likelihood of running the script. This is encapsulated by the penalty factor (P). As can be seen in the above formula, weight values for attributes that are not also in the operation (A) are multiplied by the penalty value (P), which reduces the overall score for higher penalty values and/or higher weight sums for attributes that do not also exist in the operation. In an embodiment, the default penalty multiplier is 0.05, but other values are also possible, but typically range from 0 to 0.1.

The risk referred to above is the risk that the wrong set of operations within a script will be executed on the remote system that are attempting to be fixed. For example, if there are two scripts A and B, where Script A has 5 attributes while Script B has 25 attributes, and the operation trying to run has failed has 6 attributes (1, 2, 3, 4, 5 and 6). Script A matches 5 of the 6 attributes while Script B matches 6 attributes but has an additional 19 it also looks out for. Based on the ZAP algorithm, even though Script B has more matches to the failed operation than Script A (6 matches vs 5 matches) the additional 19 attributes within Script B will lower the score. The risk again, is that Script B is most likely not the correct script to run and if ran, the risk is that it will not fix the problem.

In step, 508, the self-healing process executes the script with the highest score, 510. However, if two or more scripts are tied for the highest score, as determined in step 508, the self-healing process selects a script at random, 512.

The weighted attribute embodiment can be used in several different real-world use cases. One example case is a backup storage system (like PowerProtect DD) that is running out of storage or has reached 100% storage usage. The attributes for the operation that is running could be: disk usage and CPU usage. A few scripts in the script library have some or all the six attributes listed above. One such script may be called “Run Garbage Collection” which has the following five weighted attributes:

Disk Usage: 100%

CPU Usage: 0%

Memory Usage: 0%

Bandwidth Usage: 0%

Number of Active Connections: 0%

Another script may be called “Out of Memory Killer” which has the following weights:

Disk Usage: 10%

CPU Usage: 10%

Memory Usage: 80%

Bandwidth Usage: 0%

Number of Active Connections: 0%

When running the ZAP formula, it can be seen that the Run Garbage Collection script has a score of 100 while the Out of Memory Killer script has a score of 16. Therefore, Run Garbage Collection is picked to run.

Multiple Scripts

Embodiments described above automate the timely remediation of issues via a process that matches failed operations to one or more scripts that are most likely to fix problems without causing additional side effects, thus minimizing unavailability of services and loss of data. Embodiments further include an enhancement to the single and multiple-script embodiments by also analyzing and scoring multiple script combinations in order to improve the likelihood of remediation. Through this process, single script scores and multiple script scores are computed and compared. The script or set of scripts with the highest score will then be executed by the self-healing process.

As described above, the self-healing process automates the timely remediation of issues that may cause data loss by matching failed operations to one or more scripts that are likely to fix problems without causing additional side effects. The process enables a failed operation to run successfully by executing the single script that is determined to be the most appropriate before re-running the failed operation. In an embodiment, multiple script combinations are analyzed and scored in order to improve the likelihood of remediation. For this embodiment, single script scores and multiple script scores are computed and compared, and the script or set of scripts with the highest score is executed by the self-healing process.

As described above, the self-healing process 121 runs as a process within the backup software 202 or as an independent process, and utilizes a script library 220 that stores a set of scripts that, when executed, act upon the data protection system. These scripts contain information with a specified format in its header about the system attributes that it affects and the weight per attribute in each script.

For example, a Python script called ‘createMissingStorageUnit.py’ affects two system attributes, and has a large affect (71%) on “deviceType” and a smaller affect (29%) “storageUnit.” For this example, the script header would contain the following lines to denote the attributes and their weights as follows, where the weights and attributes are manually assigned by the script author:

-   -   “#attribute=deviceType@71”     -   “#attribute=storageUnit@29”

The self-healing process 210 scores each script in relation to a failed operation to determine which script(s) have the highest likelihood of enabling the operation to be rerun successfully.

The process 210 scores each script or combination of scripts in relation to an operation that has failed. It uses the script or script combination that has the highest score to determine which script(s) to execute, where the goal is to execute these script(s) so that the system can successfully rerun the failed operation. Each operation has an identified set of attributes that it uses or modifies, and each Script has an identified set of attributes that it modifies. A weight is associated with each attribute per script.

FIG. 6 is a flowchart illustrating a process of issuing an alert through a self-healing process using weighted attributes for multiple scripts, under some embodiments. As shown in process 600 of FIG. 6 , when a failed operation issues an alert 602, the self-healing process 210 scans through the script library 220 and generates a score for each script individually and for each combination of scripts for multiple possible scripts 604. In this case, the process first determines all of the different combinations of scripts to generate sets of scripts, 603. For example, if there 3 scripts, there are 4 combinations (AB, AC, BC, ABC) of combined scripts in addition to the 3 individual scripts. Likewise, for 4 scripts, there are 11 combinations of unordered combined scripts in addition to the 4 individual scripts, and so on.

In an embodiment, the order of combined scripts does not matter so that executing script 1 before script 2 is the same as executing script 2 before script 1. For cases where the order of scripts does matter so that these two executions would yield different results, the execution order is not commutative (i.e., AB does not equal BA), and the number of possible combinations would increase, such as 3 scripts having 10 possible permutations: A, B, C, AB, BA, AC, CA, BC, CB, ABC (or 7 if the single script option is ignored).

Each attribute in each script has a weighting, which is proportional to how much the script affects each attribute. If an attribute weight is 42, that mean the script spends 42% of its effort to affect an attribute. To process these weights, the sum of the weights per script should always equal 100. However, when multiple scripts are scored, it is possible that the sum of the weights will not equal 100. In this case, the weights are modified using a normalization calculation so that the sum of the normalized weights equal 100, step 605. This normalization is necessary so that scores of single scripts and multiple scripts can be easily compared in order to find the script or scripts that have the highest likelihood of rectifying the error encountered by the operation.

Each script thus has a list of attributes and weights per attribute that the script affects, and the sum of all weights must always add up to 100, either with or without normalization. The score is the sum of the script attribute weights in common between the operation and scripts minus a penalty multiplier for each attribute weight that is in the scripts, and not in the operation, in accordance with the ZAP scoring formula given above, step 606.

The penalty factor (P) is applied to reduce the likelihood of undesired side effects, and if two or more scripts or script combinations are tied for the highest score, as determined in step 608, the process executes one at random, 612. Otherwise, the process executes the script or set of scripts with the highest score, 610.

An example is provided to illustrate calculations for processing multiple scripts, such as in process 600, as follows: assume there are five (5) total attributes across the entire system named A, B, C, D and E, which is a simplification for purposes of illustration since, in practice, 20 to 50 or more attributes may be defined. An Operation (Z) affects three attributes named A, B and D, and there are three scripts in the script library and each script is determined to affect the following attributes with the associated weighting:

-   -   Script 1 affects 4 attributes and are weighted such that A=42,         B=0 (not affected), C=19, D=12, E=27;     -   Script 2 affects 5 attributes and are weighted such that A=15,         B=21, C=31, D=20, E=13; and     -   Script 3 affects 4 attributes and are weighted such that A=31,         B=21, C=20, D=0 (not affected), E=28.

The Penalty factor for attributes affected by any script and are not part of an Operation (attributes C and E in this example) is applied. For this example, the default factor is 0.2.

Under single-script scoring (e.g., FIG. 5 ), the score for individual scripts is computed using the following formula. For each individual script, the score equals the sum of weights that also exist in the operation minus a configurable penalty value (default=0.2) for each attribute in the script that is not in the operation. The scoring here is computed as follows:

-   -   Score for applying Script 1 to Failed Operation         Z=42+0+(19*−0.2)+12+(27*−0.2)=45;     -   Score for applying Script 2 to Failed Operation         Z=15+21+(31*−0.2)+20+(13*−0.2)=47;     -   Score for applying Script 3 to Failed Operation         Z=31+21+(20*−0.2)+0+(28*−0.2)=42.

Therefore, in this example case considering only single scripts, process 500 would execute script 2 as it has the highest score of 47.

Under multiple-script scoring (e.g., FIG. 6 ), the score for each combination of scripts is computed. Using the three scripts shown previously, a score will be computed for the following combinations:

-   -   Script 1 and 2     -   Script 1 and 3     -   Script 2 and 3     -   Script 1, 2 and 3

The score for each combination (or set) of multiple scripts the process of FIG. 7 is used, where FIG. 7 is a flowchart that illustrates a process of calculating a score for multiple scripts, under some embodiments. Process 700 starts with computing, for each attribute, the maximum weight across all of the scripts in each script combination, 702. The process next calculates a total initial score is computed for each script combination, 704. The weight for each attribute is normalized so that the sum of weights for any script combination equals 100, 706. The process then applies the normalization factor to each attribute weight for the combination of scripts, 708. The normalized attribute weights are then used to a compute a score using the same formula as described above for a single script, i.e., score=sum of common attributes less sum of different attributes times penalty factor, 710. This process 700 repeats for each permutation or combination of the multiple scores, and the set of scripts with the highest score is selected to be executed. In an embodiment, the final scripts of the selected set of scripts may be executed in any order.

An example is provided to illustrate the operation of process 700 of FIG. 7 as follows: to compute the score across script 1 and script 2, for each attribute, the max weight across all of the scripts in each script combination is computed:

-   -   A: max(42, 15)=42, B: max(0, 21)=21, C: max(19, 31)=31, D:         max(12,20)=20, E: max(13, 27)=27

The total initial score is computed for the script 1 and script 2 combination, so:

Script 1+script2=42+21+31+20+27=141

Since the max score for any individual script is 100, the score for any script combination must also equal 100, so the weight for each attribute is normalized so that the sum of weights for any script combination is also 100. Using the previous example where the initial score is 141, a normalization factor of 100/141 (0.71) is applied to each initial attribute weight for this script. This factor is computed for each different combination of scripts.

Applying the normalization factor to each attribute weight for the combination of scripts 1 and 2 yields:

(42*0.71)+(21*0.71)+(31*0.71)+(20*0.71)+(27*0.71)

Normalized Weights: A=30,B=15,C=22,D=14,E=19 (note that the sum=100)

These normalized attribute weights are then used to a compute a score using the same formula as described previously for a single script (sum of common attributes less sum of different attributes times penalty factor). Here, the calculation yields:

Normalized score=30+15+(22*−0.2)+14+(19*−0.2)=51

If the script library only contained script 1 and script 2, then this script combination would be executed by the self-healing process instead of any single script, as this score (51) is greater than the highest single script score which was 47 for script 2, in the single-script example given above.

In an embodiment, the calculation of scores for multiple scripts comprises first calculating the scores for each script individually (as a single script) per process 600, and then calculating the score of each set of scripts based on the different permutations of script combinations, e.g., [1, 2], [1, 3], [2, 3], [1, 2, 3] for three scripts, and so on. Once all of these scores are computed the script or script set with the highest score (or a random choice among co-highest) is selected to be run.

Alternatively, the single-script and multiple-script process can be executed in a single overall process that derives all possible script permutations for all scripts (i.e., n, n−1, n−2, n−3, and so on), and calculates the respective scores accordingly to determine the script or scripts to execute.

Though examples above described specific values of attribute weights, and so on, it should be noted that any other appropriate values may also be used. Similarly, any other application or use case with appropriate attributes, weights, and scripts may also be used in conjunction with the embodiments described herein.

In an embodiment, issues encountered in system 100 can be detected through the automatic detection process of self-healing process 121. In this case, the console could self-detect an issue when errors arise with system health and task completion. These automatically generated issues can be derived from logs, alerts, and system status events (e.g., a restore operation failed to run at the designated run time triggering error ARA0015).

The processes described herein may be implemented as computer programs executed in a computer or networked processing device and may be written in any appropriate language using any appropriate software routines. For purposes of illustration, certain programming examples are provided herein, but are not intended to limit any possible embodiments of their respective processes.

The network of FIG. 1 may comprise any number of individual client-server networks coupled over the Internet or similar large-scale network or portion thereof. Each node in the network(s) comprises a computing device capable of executing software code to perform the processing steps described herein. FIG. 8 shows a system block diagram of a computer system used to execute one or more software components of the systems and methods described herein. The computer system 1005 includes a monitor 1011, keyboard 1017, and mass storage devices 1020. Computer system 1005 further includes subsystems such as central processor 1010, system memory 1015, I/O controller 1021, display adapter 1025, serial or universal serial bus (USB) port 1030, network interface 1035, and speaker 1040. The system may also be used with computer systems with additional or fewer subsystems. For example, a computer system could include more than one processor 1010 (i.e., a multiprocessor system) or a system may include a cache memory.

Arrows such as 1045 represent the system bus architecture of computer system 1005. However, these arrows are illustrative of any interconnection scheme serving to link the subsystems. For example, speaker 1040 could be connected to the other subsystems through a port or have an internal direct connection to central processor 1010. The processor may include multiple processors or a multicore processor, which may permit parallel processing of information. Computer system 1005 is but an example of a computer system suitable for use with the present system. Other configurations of subsystems suitable for use with the present invention will be readily apparent to one of ordinary skill in the art.

Computer software products may be written in any of various suitable programming languages. The computer software product may be an independent application with data input and data display modules. Alternatively, the computer software products may be classes that may be instantiated as distributed objects. The computer software products may also be component software.

An operating system for the system 1005 may be one of the Microsoft Windows®. family of systems (e.g., Windows Server), Linux, Mac OS X, IRIX32, or IRIX64. Other operating systems may be used. Microsoft Windows is a trademark of Microsoft Corporation.

The computer may be connected to a network and may interface to other computers using this network. The network may be an intranet, internet, or the Internet, among others. The network may be a wired network (e.g., using copper), telephone network, packet network, an optical network (e.g., using optical fiber), or a wireless network, or any combination of these. For example, data and other information may be passed between the computer and components (or steps) of a system of the invention using a wireless network using a protocol such as Wi-Fi (IEEE standards 802.11, 802.11a, 802.11b, 802.11e, 802.11g, 802.11i, 802.11n, 802.11 ac, and 802.11ad, among other examples), near field communication (NFC), radio-frequency identification (RFID), mobile or cellular wireless. For example, signals from a computer may be transferred, at least in part, wirelessly to components or other computers.

In an embodiment, with a web browser executing on a computer workstation system, a user accesses a system on the World Wide Web (WWW) through a network such as the Internet. The web browser is used to download web pages or other content in various formats including HTML, XML, text, PDF, and postscript, and may be used to upload information to other parts of the system. The web browser may use uniform resource identifiers (URLs) to identify resources on the web and hypertext transfer protocol (HTTP) in transferring files on the web.

For the sake of clarity, the processes and methods herein have been illustrated with a specific flow, but it should be understood that other sequences may be possible and that some may be performed in parallel, without departing from the spirit of the invention. Additionally, steps may be subdivided or combined. As disclosed herein, software written in accordance with the present invention may be stored in some form of computer-readable medium, such as memory or CD-ROM, or transmitted over a network, and executed by a processor. More than one computer may be used, such as by using multiple computers in a parallel or load-sharing arrangement or distributing tasks across multiple computers such that, as a whole, they perform the functions of the components identified herein; i.e., they take the place of a single computer. Various functions described above may be performed by a single process or groups of processes, on a single computer or distributed over several computers. Processes may invoke other processes to handle certain tasks. A single storage device may be used, or several may be used to take the place of a single storage device.

Unless the context clearly requires otherwise, throughout the description and the claims, the words “comprise,” “comprising,” and the like are to be construed in an inclusive sense as opposed to an exclusive or exhaustive sense; that is to say, in a sense of “including, but not limited to.” Words using the singular or plural number also include the plural or singular number respectively. Additionally, the words “herein,” “hereunder,” “above,” “below,” and words of similar import refer to this application as a whole and not to any particular portions of this application. When the word “or” is used in reference to a list of two or more items, that word covers all of the following interpretations of the word: any of the items in the list, all of the items in the list and any combination of the items in the list.

All references cited herein are intended to be incorporated by reference. While one or more implementations have been described by way of example and in terms of the specific embodiments, it is to be understood that one or more implementations are not limited to the disclosed embodiments. To the contrary, it is intended to cover various modifications and similar arrangements as would be apparent to those skilled in the art. Therefore, the scope of the appended claims should be accorded the broadest interpretation so as to encompass all such modifications and similar arrangements. 

What is claimed is:
 1. A method of remediating issues encountered in a data protection system, comprising: detecting a backup operation alert message sent from one of a data manager or storage system, wherein the alert message encodes one or more attributes affected by the backup operation; scanning a script library to identify a plurality of scripts that match the alert message, wherein each script defines attributes that are weighted with an assigned value to reflect a percentage importance of a corresponding script to resolve a problem causing the alert message, and produce a weighted attribute; determining a combination of scripts among the plurality of scripts to define one or more script combinations; first generating a score for each single script of the identified scripts and second generating a score for each script combination, wherein the score factors the relevance of the script or script combination to the backup operation using the weighted attributes; and executing the script or script combination with the highest score, as the script most likely to remediate the issue causing the alert message.
 2. The method of claim 1 wherein each script contains a header listing weighted attributes of backup operations affected by the script.
 3. The method of claim 1 wherein a maximum score for any single script is of value 100, the method further comprising normalizing a weight associated with each script of the script combination so that the sum of normalized weights for the script combination equals
 100. 4. The method of claim 2 further comprising matching the weighted attributes encoded in the alert message with weighted attributes in the headers of each of the identified scripts.
 5. The method of claim 4 wherein, for each script, the score calculates a ratio of a total number of weighted attributes in the backup operation over a number of weighted attributes in the script that are also listed in the backup operation.
 6. The method of claim 5 wherein the script also calculates a penalty value that subtracts from the ratio, a number of weighted attributes in the script that are not listed in the backup operation, and wherein the penalty value is a configurable value that reduces the score of a script to avoid a possibility of an additional issue being caused by a penalized script.
 7. The method of claim 6 further comprising randomly executing a highest scoring script of a plurality of scripts having an equal highest score, or randomly selecting a highest scoring script to execute if two or more scripts have a same highest score.
 8. The method of claim 1 wherein the weighted attributes comprise at least one of: storage utilization, CPU utilization, device status as online, offline, or locked, and storage unit status as non-existent/full/unavailable.
 9. The method of claim 8 wherein the alert message comprises a text message indicating an action needed and a weighted attribute associated with the issue.
 10. The method of claim 1 wherein the script library comprises a private library stored in a network file share (NFS) accessible by the data protection system.
 11. The method of claim 10 wherein data protection system comprises a deduplicated backup system including a Data Domain file system (DDFS).
 12. A method of remediating issues encountered in a data protection system, comprising: encoding one or more attributes in an alert messages to be generated by one of a data manager or storage system in the event of attempted execution of a failed backup operation, wherein the attributes represent system resources affected by the backup operation; weighting each attribute to produce weighted attributes, wherein a weight comprises an assigned value between 0 to 100 to reflect a percentage importance of a corresponding script to resolve a problem causing the alert message; storing a plurality of scripts, each script encoded with weighted attributes affected by a respective script; identifying, in the event of a detected alert message, one or more scripts that match the alert message through matching weighted attributes within the alert message and the one or more scripts; first calculating a score for each single script of the one or more messages, and second calculating a score for each permutation of script combinations of the one or more scripts, wherein the score equals a number of matching weighted attributes and least number of non-matching weighted attributes, as the script most likely to remediate the issue causing the alert message; and selecting for execution, the script or script combination with the highest score.
 13. The method of claim 12 wherein a maximum score for any single script is of value 100, the method further comprising normalizing a weight associated with each permutation of script combinations so that the sum of normalized weights for a script combination equals
 100. 14. The method of claim 12 wherein each script contains a header listing weighted attributes of backup operations affected by the script followed by executable code processing the listed weighted attributes.
 15. The method of claim 14 further comprising, calculating, for each script, a score having a ratio of a total number of attributes in the backup operation over a number of weighted attributes in the script that are also listed in the backup operation, and a penalty value that subtracts from the ratio, a number of weighted attributes in the script that are not listed in the backup operation, wherein the penalty value reduces the score of a script to avoid a possibility of an additional issue being caused by a penalized script.
 16. The method of claim 15 wherein the weighted attributes comprise at least one of: storage utilization, CPU utilization, device status as one of online/offline/locked), and storage unit status as one of non-existent/full/unavailable, and further wherein the alert message comprises a text message indicating an action needed and an attribute associated with the issue.
 17. A method of remediating issues encountered in a data protection system, comprising: receiving a system alert message sent encoding one or more attributes affected in the data protection system; scanning a script library to identify a plurality of scripts that match the alert message, wherein each script defines weighted attributes and is configured to resolve a problem causing the alert message; first calculating a score for each single script of the identified scripts; determining a combination of scripts among the plurality of scripts to define one or more script combinations; second generating a score for each script combination, wherein the score for each individual script and each script combination factors the relevance of the respective script or script combination to the backup operation using the weighted attributes; and executing the script or script combination with the highest score, as the script most likely to remediate the issue causing the alert message.
 18. The method of claim 17 the weighted attributes are weighted with an assigned value to reflect a percentage importance of a corresponding script to resolve the problem causing the alert message, and wherein a weight comprises an assigned value between 0 to 100 to reflect a percentage importance of a corresponding script to resolve the problem, the weighted attributes comprising at least one of: storage utilization, CPU utilization, device status as one of online/offline/locked), and storage unit status as one of non-existent/full/unavailable, and further wherein the alert message comprises a text message indicating an action needed and a weighted attribute associated with the issue.
 19. The method of claim 18 wherein a maximum score for any single script is of value 100, the method further comprising normalizing a weight associated with each script of the script combination so that the sum of normalized weights for the script combination equals
 100. 20. The method of claim 19 wherein, for each script or script combination, the score calculates a ratio of a total number of weighted attributes in the backup operation over a number of attributes in the script that are also listed in the backup operation, and calculates a penalty value that subtracts from the ratio, a number of weighted attributes in the script that are not listed in the backup operation, wherein the penalty value reduces the score of a script to avoid a possibility of an additional issue being caused by a penalized script. 